{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Structure de Simtax\n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On commence par la personne (individu). Il ou elle ades revenus et un age. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "class person: \n",
    "    def __init__(self,age=50,oas=0.0,gis=0.0,earn=0.0,rpp=0.0,cpp=0.0,othtax=0.0,\n",
    "                 othntax=0.0,con_rrsp=0.0,inc_rrsp=0.0):\n",
    "        self.age = age\n",
    "        self.inc_earn = earn\n",
    "        self.inc_oas = oas\n",
    "        self.inc_gis = gis\n",
    "        self.inc_rpp = rpp\n",
    "        self.inc_cpp = cpp\n",
    "        self.con_rrsp = con_rrsp\n",
    "        self.inc_rrsp = inc_rrsp\n",
    "        self.inc_othtax = othtax \n",
    "        self.inc_othntax = othntax\n",
    "        self.inc_disp = 0.0\n",
    "        return\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "husb = person(age=65,earn=30e3)\n",
    "wife = person(age=65,earn=10e3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On enchaine avec le menage, qui peut etre compose de deux conjoints. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "class hhold:\n",
    "    def __init__(self,first,second=None):\n",
    "        self.sp = [first]\n",
    "        self.couple = False\n",
    "        if second!=None:\n",
    "            self.sp.append(second)\n",
    "            self.couple = True\n",
    "        return\n",
    "                 \n",
    "\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "hh = hhold(husb,wife)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On passe maintenant au rapport d'impot federal. Il prend comme input un menage, un individu pour qui on fait le rapport ainsi que des regles. Le rapport suit la structure du rapport d'impot\n",
    "\n",
    "* Revenu total\n",
    "* - deduction\n",
    "* Revenu imposable\n",
    "* impot\n",
    "* - credit non-remboursable\n",
    "* impot a payer (liability)\n",
    "* credit impot remboursable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "class federal:\n",
    "    def __init__(self,hhold,who,rules):\n",
    "        self.hhold = hhold\n",
    "        self.who = who\n",
    "        self.totinc = 0.0\n",
    "        self.deduc = 0.0\n",
    "        self.taxinc = 0.0\n",
    "        self.tax = 0.0\n",
    "        self.ntcred = 0.0\n",
    "        self.liab = 0.0\n",
    "        self.rtcred = 0.0\n",
    "        self.taxpay = 0.0\n",
    "        self.dspinc = 0.0\n",
    "        self.rules = rules\n",
    "        return\n",
    "    def file(self):\n",
    "        self.calc_totinc()   \n",
    "        self.calc_deduc()\n",
    "        self.calc_taxinc()\n",
    "        self.calc_tax()\n",
    "        self.calc_ntcred()\n",
    "        self.liab = self.tax - self.ntcred\n",
    "        if (self.liab < 0.0):\n",
    "            self.liab = 0.0\n",
    "        self.calc_rtcred()\n",
    "        return\n",
    "    def calc_totinc(self):\n",
    "        p = self.hhold.sp[self.who]\n",
    "        self.totinc += p.inc_earn\n",
    "        self.totinc += p.inc_oas\n",
    "        self.totinc += p.inc_gis        \n",
    "        self.totinc += p.inc_rpp\n",
    "        self.totinc += p.inc_cpp\n",
    "        self.totinc += p.inc_othtax\n",
    "        self.totinc += p.inc_othntax\n",
    "        self.totinc += p.inc_rrsp\n",
    "        return\n",
    "    def calc_deduc(self):\n",
    "        p = self.hhold.sp[self.who]\n",
    "        self.deduc += p.con_rrsp\n",
    "        return\n",
    "    def calc_taxinc(self):\n",
    "        p = self.hhold.sp[self.who]\n",
    "        self.taxinc = self.totinc\n",
    "        self.taxinc -= p.inc_gis\n",
    "        self.taxinc -= self.deduc\n",
    "        return\n",
    "    def calc_tax(self):\n",
    "        brack = self.rules.brack\n",
    "        rates = self.rules.rates\n",
    "        i = self.taxinc\n",
    "        t = 0.0\n",
    "        g = 0.0\n",
    "        for b,r in zip(brack,rates):\n",
    "            if (i>b):\n",
    "                t+=r*(b-g)\n",
    "                g=b\n",
    "            else :\n",
    "                t+=r*(i-g)\n",
    "                break\n",
    "        self.tax = t\n",
    "        return\n",
    "    def calc_ntcred(self):\n",
    "        self.ntcred += self.rules.rates[0]*self.rules.base\n",
    "        return\n",
    "    def calc_rtcred(self):\n",
    "        pass\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On fait la meme chose pour le rapport provincial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "class quebec:\n",
    "    def __init__(self,hhold,who,rules):\n",
    "        self.hhold = hhold\n",
    "        self.who = who\n",
    "        self.totinc = 0.0\n",
    "        self.deduc = 0.0\n",
    "        self.taxinc = 0.0\n",
    "        self.tax = 0.0\n",
    "        self.ntcred = 0.0\n",
    "        self.liab = 0.0\n",
    "        self.rtcred = 0.0\n",
    "        self.taxpay = 0.0\n",
    "        self.dspinc = 0.0\n",
    "        self.rules = rules\n",
    "        return\n",
    "    def file(self):\n",
    "        self.calc_totinc()   \n",
    "        self.calc_deduc()\n",
    "        self.calc_taxinc()\n",
    "        self.calc_tax()\n",
    "        self.calc_ntcred()\n",
    "        self.liab = self.tax - self.ntcred\n",
    "        if (self.liab < 0.0):\n",
    "            self.liab = 0.0\n",
    "        self.calc_rtcred()\n",
    "        return\n",
    "    def calc_totinc(self):\n",
    "        p = self.hhold.sp[self.who]\n",
    "        self.totinc += p.inc_earn\n",
    "        self.totinc += p.inc_oas\n",
    "        self.totinc += p.inc_gis        \n",
    "        self.totinc += p.inc_rpp\n",
    "        self.totinc += p.inc_cpp\n",
    "        self.totinc += p.inc_othtax\n",
    "        self.totinc += p.inc_othntax\n",
    "        self.totinc += p.inc_rrsp\n",
    "        return\n",
    "    def calc_deduc(self):\n",
    "        p = self.hhold.sp[self.who]\n",
    "        self.deduc += p.con_rrsp\n",
    "        return\n",
    "    def calc_taxinc(self):\n",
    "        p = self.hhold.sp[self.who]\n",
    "        self.taxinc = self.totinc\n",
    "        self.taxinc -= p.inc_gis\n",
    "        self.taxinc -= self.deduc\n",
    "        return    \n",
    "    def calc_tax(self):\n",
    "        brack = self.rules.brack\n",
    "        rates = self.rules.rates\n",
    "        i = self.taxinc\n",
    "        t = 0.0\n",
    "        g = 0.0\n",
    "        for b,r in zip(brack,rates):\n",
    "            if (i>=b):\n",
    "                t+=r*(b-g)\n",
    "                g=b\n",
    "            else :\n",
    "                t+=r*(i-g)\n",
    "                break\n",
    "        self.tax = t\n",
    "        return\n",
    "    def calc_ntcred(self):\n",
    "        self.ntcred += self.rules.rates[0]*self.rules.base\n",
    "        self.ntcred += self.get_agecred()\n",
    "        return\n",
    "    def get_agecred(self):\n",
    "        p = self.hhold.sp[self.who]\n",
    "        inc = self.taxinc\n",
    "        nage = self.rules.nrtc_age\n",
    "        nmax = self.rules.nrtc_age_max\n",
    "        nbas = self.rules.nrtc_age_base\n",
    "        rate = self.rules.nrtc_age_rate\n",
    "        elig = p.age>=nage\n",
    "        amount = 0.0\n",
    "        if elig: \n",
    "            amount += nmax\n",
    "            if (inc > nbas):\n",
    "                amount -= rate*(inc-nbas)     \n",
    "                if (amount <0.0):\n",
    "                    amount = 0.0\n",
    "        return amount\n",
    "    def calc_rtcred(self):\n",
    "        pass\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On creer aussi les programmes OAS et GIS:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "class oas:\n",
    "    def __init__(self,hhold,who,rules):\n",
    "        self.hhold = hhold\n",
    "        self.who = who\n",
    "        self.p = self.hhold.sp[self.who]\n",
    "        self.elig = False\n",
    "        self.oasinc = 0.0\n",
    "        self.rules = rules\n",
    "        return\n",
    "    def oaselig(self):\n",
    "        if self.p.age>=self.rules.age:\n",
    "            self.elig = True\n",
    "        return\n",
    "    def file(self):\n",
    "        self.oaselig()\n",
    "        if (self.elig):\n",
    "            self.oasinc = self.rules.base\n",
    "        self.clawback()\n",
    "        return\n",
    "    def clawback(self):\n",
    "        inc = self.p.inc_earn + self.p.inc_rpp + self.p.inc_cpp + self.p.inc_othtax \n",
    "        claw = max(self.rules.rate*(inc-self.rules.brack),0.0)\n",
    "        if (claw > self.oasinc):\n",
    "            self.oasinc = 0.0\n",
    "        else :\n",
    "            self.oasinc -= claw\n",
    "        return\n",
    "\n",
    "class gis:\n",
    "    def __init__(self,hhold,who,rules):\n",
    "        self.hhold = hhold\n",
    "        self.who = who\n",
    "        self.p = self.hhold.sp[self.who]\n",
    "        self.elig = False\n",
    "        self.gisinc = 0.0\n",
    "        self.rules = rules\n",
    "        return\n",
    "    def giselig(self):\n",
    "        if self.p.age>=self.rules.age:\n",
    "            self.elig = True\n",
    "        return\n",
    "    def file(self):\n",
    "        self.giselig()\n",
    "        if (self.elig):\n",
    "            self.gisinc = self.rules.base\n",
    "        self.clawback()\n",
    "        return\n",
    "    def clawback(self):\n",
    "        inc = self.p.inc_earn + self.p.inc_rpp + self.p.inc_cpp + self.p.inc_othtax \n",
    "        claw = max(self.rules.rate*(inc-self.rules.brack),0.0)\n",
    "        if (claw > self.gisinc):\n",
    "            self.gisinc = 0.0\n",
    "        else :\n",
    "            self.gisinc -= claw\n",
    "        return\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les classes de parametres vide pour chaqun des programmes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class fedpars:\n",
    "    def __init__(self):\n",
    "        self.brack = []\n",
    "        self.rates = []\n",
    "        self.base = 0.0\n",
    "        return\n",
    "\n",
    "class qcpars:\n",
    "    def __init__(self,year):\n",
    "        self.year = year\n",
    "        self.brack = []\n",
    "        self.rates = []\n",
    "        self.base = 0.0\n",
    "        self.witb = 0.0\n",
    "        self.nrtc_age = 0.0\n",
    "        self.nrtc_age_max = 0.0\n",
    "        self.nrtc_age_base = 0.0\n",
    "        self.nrtc_age_rate = 0.0\n",
    "        self.parnames = [s for s in self.__dict__.keys()]\n",
    "        self.parnames = self.parnames[1:]\n",
    "        self.path = 'pars/'+str(self.year)+'/qc/'\n",
    "        return\n",
    "    def loadpars(self):\n",
    "        with open(self.path+'values.csv') as csvfile:\n",
    "            reader = csv.reader(csvfile,delimiter=';')\n",
    "            for i,row in enumerate(reader):\n",
    "                if (row[0] in self.parnames):\n",
    "                    d = [float(r) for r in row[1:] if r!='']\n",
    "                    if (len(d)==1):\n",
    "                        d = d[0]\n",
    "                    self.__setattr__(row[0],d)\n",
    "        return\n",
    "        \n",
    "class oaspars:\n",
    "    def __init__(self):\n",
    "        self.year = 2018\n",
    "        self.age = 65\n",
    "        self.base = 0.0\n",
    "        self.rate = 0.0\n",
    "        self.brack = 0.0\n",
    "        return\n",
    "class gispars:\n",
    "    def __init__(self):\n",
    "        self.year = 2018\n",
    "        self.age = 65\n",
    "        self.base = 0.0\n",
    "        self.rate = 0.0\n",
    "        self.brack = 0.0\n",
    "        return\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a maintenant la classe principale simtax, qui prendra comme input des menages. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "class simtax:\n",
    "    def __init__(self,year=2015,prov='qc'):\n",
    "        self.year = year\n",
    "        self.prov = prov\n",
    "        self.loadfederal()\n",
    "        self.loadprovincial()\n",
    "        self.loadoas()\n",
    "        self.loadgis()\n",
    "        return\n",
    "    def loadfederal(self):\n",
    "        if (self.year==2018):\n",
    "            self.fed = fedpars()\n",
    "            self.fed.year = 2018\n",
    "            self.fed.brack = [45e3,91e3,142e3,202e3,10e6]\n",
    "            self.fed.rates = [0.14,0.205,0.26,0.29,0.33]\n",
    "            self.fed.base = 14e3\n",
    "        return\n",
    "    def loadprovincial(self):\n",
    "        if (self.prov=='qc'):     \n",
    "            if (self.year==2018):\n",
    "                self.pro = qcpars(self.year)      \n",
    "                self.pro.loadpars()\n",
    "        return\n",
    "    def loadoas(self):\n",
    "        if (self.year==2018):\n",
    "            self.oasp = oaspars()\n",
    "            self.oasp.year = 2018\n",
    "            self.oasp.age = 65\n",
    "            self.oasp.base = 8000.0\n",
    "            self.oasp.rate = 0.33\n",
    "            self.oasp.brack = 70e3\n",
    "        return\n",
    "    def loadgis(self):\n",
    "        if (self.year==2018):\n",
    "            self.gisp = gispars()\n",
    "            self.gisp.year = 2018\n",
    "            self.gisp.age = 65\n",
    "            self.gisp.base = 7000.0\n",
    "            self.gisp.rate = 0.5\n",
    "            self.gisp.brack = 5e3\n",
    "        return\n",
    "    def file(self,hhold):\n",
    "        # get oas\n",
    "        self.fileoas(hhold)\n",
    "        # get gis\n",
    "        self.filegis(hhold)        \n",
    "        # federal taxes\n",
    "        self.filefed(hhold)\n",
    "        # provincial taxes\n",
    "        self.filepro(hhold)\n",
    "        return\n",
    "    def fileoas(self,hhold):\n",
    "        for i,s in enumerate(hhold.sp):\n",
    "            form = oas(hhold,i,self.oasp)\n",
    "            form.file()\n",
    "            hhold.sp[i].inc_oas = form.oasinc\n",
    "        return\n",
    "    def filegis(self,hhold):\n",
    "        for i,s in enumerate(hhold.sp):\n",
    "            form = gis(hhold,i,self.gisp)\n",
    "            form.file()\n",
    "            hhold.sp[i].inc_gis = form.gisinc\n",
    "        return\n",
    "    def filefed(self,hhold):\n",
    "        self.fedforms = []\n",
    "        for i,sp in enumerate(hhold.sp):\n",
    "            self.fedforms.append(federal(hhold,i,self.fed))\n",
    "            self.fedforms[i].file()\n",
    "        return\n",
    "    def filepro(self,hhold):\n",
    "        if (self.prov=='qc'):\n",
    "            self.proforms = []\n",
    "            for i,sp in enumerate(hhold.sp):\n",
    "                self.proforms.append(quebec(hhold,i,self.pro))\n",
    "                self.proforms[i].file()\n",
    "        return        \n",
    "    def paftertax(self,hhold,who):\n",
    "        inc_disp = 0.0\n",
    "        inc_disp += self.fedforms[who].totinc\n",
    "        inc_disp -= self.fedforms[who].liab\n",
    "        inc_disp -= self.proforms[who].liab\n",
    "        inc_disp += self.fedforms[who].rtcred\n",
    "        inc_disp += self.proforms[who].rtcred\n",
    "        return inc_disp\n",
    "    def haftertax(self,hhold):\n",
    "        hh = 0.0\n",
    "        for i,p in enumerate(hhold.sp):\n",
    "            hh += self.paftertax(hhold,i)\n",
    "        return hh\n",
    "    def pinc(self,hhold,who):\n",
    "        return self.fedforms[who].totinc\n",
    "    def hinc(self,hhold):\n",
    "        hh = 0.0\n",
    "        for i,p in enumerate(hhold.sp):\n",
    "            hh += self.pinc(hhold,i)\n",
    "        return hh\n",
    "    def patr(self,hhold,who):\n",
    "        rate = 1.0-self.paftertax(hhold,who)/self.pinc(hhold,who)\n",
    "        return rate\n",
    "    def pmtr(self,hhold,who,incre):\n",
    "        self.file(hhold)\n",
    "        inc   = self.paftertax(hhold,who)\n",
    "        hholdp = hhold\n",
    "        hholdp.sp[who].inc_earn += incre\n",
    "        self.file(hholdp)\n",
    "        incp    = self.paftertax(hhold,who)\n",
    "        rate = 1.0 - (incp - inc)/incre\n",
    "        return rate\n",
    "    def hatr(self,hhold):\n",
    "        rate = 1.0-self.haftertax(hhold)/self.hinc(hhold)\n",
    "        return rate\n",
    "    def hmtr(self,hhold,who,incre):\n",
    "        self.file(hhold)\n",
    "        inc   = self.haftertax(hhold)\n",
    "        hholdp = hhold\n",
    "        hholdp.sp[who].inc_earn += incre\n",
    "        self.file(hholdp)\n",
    "        incp    = self.haftertax(hhold)\n",
    "        rate = 1.0 - (incp - inc)/incre\n",
    "        return rate      \n",
    "     \n",
    "        \n",
    "    \n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Petit exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "this = simtax(year=2018)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "this.file(hh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21673.4"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this.paftertax(hh,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "266.60000000000036"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this.proforms[1].liab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taux moyen impot personel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.17570000000000008, 0.03673777777777776]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[this.patr(hh,0),this.patr(hh,1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taux marginaux imposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.28, 0.88]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[this.pmtr(hh,0,1e3),this.pmtr(hh,1,1e3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Au niveau du menage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62000.0"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this.hinc(hh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.13166451612903218"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this.hatr(hh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.88"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this.hmtr(hh,1,1e3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Petit exemple d'experience sur taux marginaux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "earns = np.linspace(0.0,250e3,100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "mtrs = []\n",
    "for e in earns:\n",
    "    hh.sp[0].inc_earn = e\n",
    "    mtrs.append(this.hmtr(hh,0,1e3))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "plt.figure()\n",
    "plt.plot(earns,mtrs)\n",
    "plt.xlabel('earning of person 1')\n",
    "plt.ylabel('household marginal tax rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Changeons le clawback rate du GIS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "this.gisp.rate = 0.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "mtrs2 = []\n",
    "for e in earns:\n",
    "    hh.sp[0].inc_earn = e\n",
    "    mtrs2.append(this.hmtr(hh,0,1e3))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "plt.figure()\n",
    "plt.plot(earns,mtrs,label='baseline')\n",
    "plt.plot(earns,mtrs2,label='lower clawback')\n",
    "plt.xlabel('earning of person 1')\n",
    "plt.ylabel('household marginal tax rate')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
